// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.inventory.model.variation;

import com.fowo.api.common.model.PageSearch;
import java.util.Date;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class InventoryVariationSearchParamPo extends PageSearch {

  /**
   * 仓库内码
   */
  private Integer stockId;

  /**
   * 最小仓库内码
   */
  private Integer stockIdMin;

  /**
   * 最大仓库内码
   */
  private Integer stockIdMax;

  /**
   * 仓库内码 比较(eq)
   */
  private Integer stockIdEq;
  /**
   * 仓库内码 比较(neq)
   */
  private Integer stockIdNeq;
  /**
   * 仓库内码 比较(gt)
   */
  private Integer stockIdGt;
  /**
   * 仓库内码 比较(gte)
   */
  private Integer stockIdGte;
  /**
   * 仓库内码 比较(lt)
   */
  private Integer stockIdLt;
  /**
   * 仓库内码 比较(lte)
   */
  private Integer stockIdLte;
  /**
   * 仓库内码 比较(contains)
   */
  private Integer stockIdContains;
  /**
   * 仓库内码 比较(notcontains)
   */
  private Integer stockIdNotcontains;
  /**
   * 仓库内码 比较(startswith)
   */
  private Integer stockIdStartswith;
  /**
   * 仓库内码 比较(endswith)
   */
  private Integer stockIdEndswith;
  /**
   * 仓库内码 比较(isnull)
   */
  private Boolean stockIdIsnull;
  /**
   * 仓库内码 比较(isnotnull)
   */
  private Boolean stockIdIsnotnull;

  /**
   * 项目内码
   */
  private Integer projectId;

  /**
   * 最小项目内码
   */
  private Integer projectIdMin;

  /**
   * 最大项目内码
   */
  private Integer projectIdMax;

  /**
   * 项目内码 比较(eq)
   */
  private Integer projectIdEq;
  /**
   * 项目内码 比较(neq)
   */
  private Integer projectIdNeq;
  /**
   * 项目内码 比较(gt)
   */
  private Integer projectIdGt;
  /**
   * 项目内码 比较(gte)
   */
  private Integer projectIdGte;
  /**
   * 项目内码 比较(lt)
   */
  private Integer projectIdLt;
  /**
   * 项目内码 比较(lte)
   */
  private Integer projectIdLte;
  /**
   * 项目内码 比较(contains)
   */
  private Integer projectIdContains;
  /**
   * 项目内码 比较(notcontains)
   */
  private Integer projectIdNotcontains;
  /**
   * 项目内码 比较(startswith)
   */
  private Integer projectIdStartswith;
  /**
   * 项目内码 比较(endswith)
   */
  private Integer projectIdEndswith;
  /**
   * 项目内码 比较(isnull)
   */
  private Boolean projectIdIsnull;
  /**
   * 项目内码 比较(isnotnull)
   */
  private Boolean projectIdIsnotnull;

  /**
   * 物料内码
   */
  private Integer itemId;

  /**
   * 最小物料内码
   */
  private Integer itemIdMin;

  /**
   * 最大物料内码
   */
  private Integer itemIdMax;

  /**
   * 物料内码 比较(eq)
   */
  private Integer itemIdEq;
  /**
   * 物料内码 比较(neq)
   */
  private Integer itemIdNeq;
  /**
   * 物料内码 比较(gt)
   */
  private Integer itemIdGt;
  /**
   * 物料内码 比较(gte)
   */
  private Integer itemIdGte;
  /**
   * 物料内码 比较(lt)
   */
  private Integer itemIdLt;
  /**
   * 物料内码 比较(lte)
   */
  private Integer itemIdLte;
  /**
   * 物料内码 比较(contains)
   */
  private Integer itemIdContains;
  /**
   * 物料内码 比较(notcontains)
   */
  private Integer itemIdNotcontains;
  /**
   * 物料内码 比较(startswith)
   */
  private Integer itemIdStartswith;
  /**
   * 物料内码 比较(endswith)
   */
  private Integer itemIdEndswith;
  /**
   * 物料内码 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 物料内码 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;

  /**
   * 批号(模糊搜索)
   */
  private String batchNo;

  /**
   * 批号 比较(eq)
   */
  private String batchNoEq;
  /**
   * 批号 比较(neq)
   */
  private String batchNoNeq;
  /**
   * 批号 比较(gt)
   */
  private String batchNoGt;
  /**
   * 批号 比较(gte)
   */
  private String batchNoGte;
  /**
   * 批号 比较(lt)
   */
  private String batchNoLt;
  /**
   * 批号 比较(lte)
   */
  private String batchNoLte;
  /**
   * 批号 比较(contains)
   */
  private String batchNoContains;
  /**
   * 批号 比较(notcontains)
   */
  private String batchNoNotcontains;
  /**
   * 批号 比较(startswith)
   */
  private String batchNoStartswith;
  /**
   * 批号 比较(endswith)
   */
  private String batchNoEndswith;
  /**
   * 批号 比较(isnull)
   */
  private Boolean batchNoIsnull;
  /**
   * 批号 比较(isnotnull)
   */
  private Boolean batchNoIsnotnull;

  /**
   * 变动类型(模糊搜索)
   */
  private String changeType;

  /**
   * 变动类型 比较(eq)
   */
  private String changeTypeEq;
  /**
   * 变动类型 比较(neq)
   */
  private String changeTypeNeq;
  /**
   * 变动类型 比较(gt)
   */
  private String changeTypeGt;
  /**
   * 变动类型 比较(gte)
   */
  private String changeTypeGte;
  /**
   * 变动类型 比较(lt)
   */
  private String changeTypeLt;
  /**
   * 变动类型 比较(lte)
   */
  private String changeTypeLte;
  /**
   * 变动类型 比较(contains)
   */
  private String changeTypeContains;
  /**
   * 变动类型 比较(notcontains)
   */
  private String changeTypeNotcontains;
  /**
   * 变动类型 比较(startswith)
   */
  private String changeTypeStartswith;
  /**
   * 变动类型 比较(endswith)
   */
  private String changeTypeEndswith;
  /**
   * 变动类型 比较(isnull)
   */
  private Boolean changeTypeIsnull;
  /**
   * 变动类型 比较(isnotnull)
   */
  private Boolean changeTypeIsnotnull;

  /**
   * 变动源类型(模糊搜索)
   */
  private String fromType;

  /**
   * 变动源类型 比较(eq)
   */
  private String fromTypeEq;
  /**
   * 变动源类型 比较(neq)
   */
  private String fromTypeNeq;
  /**
   * 变动源类型 比较(gt)
   */
  private String fromTypeGt;
  /**
   * 变动源类型 比较(gte)
   */
  private String fromTypeGte;
  /**
   * 变动源类型 比较(lt)
   */
  private String fromTypeLt;
  /**
   * 变动源类型 比较(lte)
   */
  private String fromTypeLte;
  /**
   * 变动源类型 比较(contains)
   */
  private String fromTypeContains;
  /**
   * 变动源类型 比较(notcontains)
   */
  private String fromTypeNotcontains;
  /**
   * 变动源类型 比较(startswith)
   */
  private String fromTypeStartswith;
  /**
   * 变动源类型 比较(endswith)
   */
  private String fromTypeEndswith;
  /**
   * 变动源类型 比较(isnull)
   */
  private Boolean fromTypeIsnull;
  /**
   * 变动源类型 比较(isnotnull)
   */
  private Boolean fromTypeIsnotnull;

  /**
   * 变动目标类型(模糊搜索)
   */
  private String toType;

  /**
   * 变动目标类型 比较(eq)
   */
  private String toTypeEq;
  /**
   * 变动目标类型 比较(neq)
   */
  private String toTypeNeq;
  /**
   * 变动目标类型 比较(gt)
   */
  private String toTypeGt;
  /**
   * 变动目标类型 比较(gte)
   */
  private String toTypeGte;
  /**
   * 变动目标类型 比较(lt)
   */
  private String toTypeLt;
  /**
   * 变动目标类型 比较(lte)
   */
  private String toTypeLte;
  /**
   * 变动目标类型 比较(contains)
   */
  private String toTypeContains;
  /**
   * 变动目标类型 比较(notcontains)
   */
  private String toTypeNotcontains;
  /**
   * 变动目标类型 比较(startswith)
   */
  private String toTypeStartswith;
  /**
   * 变动目标类型 比较(endswith)
   */
  private String toTypeEndswith;
  /**
   * 变动目标类型 比较(isnull)
   */
  private Boolean toTypeIsnull;
  /**
   * 变动目标类型 比较(isnotnull)
   */
  private Boolean toTypeIsnotnull;

  /**
   * 关联单据号(模糊搜索)
   */
  private String formNum;

  /**
   * 关联单据号 比较(eq)
   */
  private String formNumEq;
  /**
   * 关联单据号 比较(neq)
   */
  private String formNumNeq;
  /**
   * 关联单据号 比较(gt)
   */
  private String formNumGt;
  /**
   * 关联单据号 比较(gte)
   */
  private String formNumGte;
  /**
   * 关联单据号 比较(lt)
   */
  private String formNumLt;
  /**
   * 关联单据号 比较(lte)
   */
  private String formNumLte;
  /**
   * 关联单据号 比较(contains)
   */
  private String formNumContains;
  /**
   * 关联单据号 比较(notcontains)
   */
  private String formNumNotcontains;
  /**
   * 关联单据号 比较(startswith)
   */
  private String formNumStartswith;
  /**
   * 关联单据号 比较(endswith)
   */
  private String formNumEndswith;
  /**
   * 关联单据号 比较(isnull)
   */
  private Boolean formNumIsnull;
  /**
   * 关联单据号 比较(isnotnull)
   */
  private Boolean formNumIsnotnull;

  /**
   * 关联制单人(模糊搜索)
   */
  private String formOperator;

  /**
   * 关联制单人 比较(eq)
   */
  private String formOperatorEq;
  /**
   * 关联制单人 比较(neq)
   */
  private String formOperatorNeq;
  /**
   * 关联制单人 比较(gt)
   */
  private String formOperatorGt;
  /**
   * 关联制单人 比较(gte)
   */
  private String formOperatorGte;
  /**
   * 关联制单人 比较(lt)
   */
  private String formOperatorLt;
  /**
   * 关联制单人 比较(lte)
   */
  private String formOperatorLte;
  /**
   * 关联制单人 比较(contains)
   */
  private String formOperatorContains;
  /**
   * 关联制单人 比较(notcontains)
   */
  private String formOperatorNotcontains;
  /**
   * 关联制单人 比较(startswith)
   */
  private String formOperatorStartswith;
  /**
   * 关联制单人 比较(endswith)
   */
  private String formOperatorEndswith;
  /**
   * 关联制单人 比较(isnull)
   */
  private Boolean formOperatorIsnull;
  /**
   * 关联制单人 比较(isnotnull)
   */
  private Boolean formOperatorIsnotnull;

  /**
   * 操作业务名称(模糊搜索)
   */
  private String operate;

  /**
   * 操作业务名称 比较(eq)
   */
  private String operateEq;
  /**
   * 操作业务名称 比较(neq)
   */
  private String operateNeq;
  /**
   * 操作业务名称 比较(gt)
   */
  private String operateGt;
  /**
   * 操作业务名称 比较(gte)
   */
  private String operateGte;
  /**
   * 操作业务名称 比较(lt)
   */
  private String operateLt;
  /**
   * 操作业务名称 比较(lte)
   */
  private String operateLte;
  /**
   * 操作业务名称 比较(contains)
   */
  private String operateContains;
  /**
   * 操作业务名称 比较(notcontains)
   */
  private String operateNotcontains;
  /**
   * 操作业务名称 比较(startswith)
   */
  private String operateStartswith;
  /**
   * 操作业务名称 比较(endswith)
   */
  private String operateEndswith;
  /**
   * 操作业务名称 比较(isnull)
   */
  private Boolean operateIsnull;
  /**
   * 操作业务名称 比较(isnotnull)
   */
  private Boolean operateIsnotnull;

  /**
   * 关联唯一操作键(模糊搜索)
   */
  private String operateKey;

  /**
   * 关联唯一操作键 比较(eq)
   */
  private String operateKeyEq;
  /**
   * 关联唯一操作键 比较(neq)
   */
  private String operateKeyNeq;
  /**
   * 关联唯一操作键 比较(gt)
   */
  private String operateKeyGt;
  /**
   * 关联唯一操作键 比较(gte)
   */
  private String operateKeyGte;
  /**
   * 关联唯一操作键 比较(lt)
   */
  private String operateKeyLt;
  /**
   * 关联唯一操作键 比较(lte)
   */
  private String operateKeyLte;
  /**
   * 关联唯一操作键 比较(contains)
   */
  private String operateKeyContains;
  /**
   * 关联唯一操作键 比较(notcontains)
   */
  private String operateKeyNotcontains;
  /**
   * 关联唯一操作键 比较(startswith)
   */
  private String operateKeyStartswith;
  /**
   * 关联唯一操作键 比较(endswith)
   */
  private String operateKeyEndswith;
  /**
   * 关联唯一操作键 比较(isnull)
   */
  private Boolean operateKeyIsnull;
  /**
   * 关联唯一操作键 比较(isnotnull)
   */
  private Boolean operateKeyIsnotnull;

  /**
   * 最早操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operateTimeStart;

  /**
   * 最晚操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operateTimeEnd;

  /**
   * 操作时间 比较(eq)
   */
  private Date operateTimeEq;
  /**
   * 操作时间 比较(neq)
   */
  private Date operateTimeNeq;
  /**
   * 操作时间 比较(gt)
   */
  private Date operateTimeGt;
  /**
   * 操作时间 比较(gte)
   */
  private Date operateTimeGte;
  /**
   * 操作时间 比较(lt)
   */
  private Date operateTimeLt;
  /**
   * 操作时间 比较(lte)
   */
  private Date operateTimeLte;
  /**
   * 操作时间 比较(contains)
   */
  private Date operateTimeContains;
  /**
   * 操作时间 比较(notcontains)
   */
  private Date operateTimeNotcontains;
  /**
   * 操作时间 比较(startswith)
   */
  private Date operateTimeStartswith;
  /**
   * 操作时间 比较(endswith)
   */
  private Date operateTimeEndswith;
  /**
   * 操作时间 比较(isnull)
   */
  private Boolean operateTimeIsnull;
  /**
   * 操作时间 比较(isnotnull)
   */
  private Boolean operateTimeIsnotnull;

  /**
   * 库存数量
   */
  private java.math.BigDecimal stockQty;

  /**
   * 最小库存数量
   */
  private java.math.BigDecimal stockQtyMin;

  /**
   * 最大库存数量
   */
  private java.math.BigDecimal stockQtyMax;

  /**
   * 库存数量 比较(eq)
   */
  private java.math.BigDecimal stockQtyEq;
  /**
   * 库存数量 比较(neq)
   */
  private java.math.BigDecimal stockQtyNeq;
  /**
   * 库存数量 比较(gt)
   */
  private java.math.BigDecimal stockQtyGt;
  /**
   * 库存数量 比较(gte)
   */
  private java.math.BigDecimal stockQtyGte;
  /**
   * 库存数量 比较(lt)
   */
  private java.math.BigDecimal stockQtyLt;
  /**
   * 库存数量 比较(lte)
   */
  private java.math.BigDecimal stockQtyLte;
  /**
   * 库存数量 比较(contains)
   */
  private java.math.BigDecimal stockQtyContains;
  /**
   * 库存数量 比较(notcontains)
   */
  private java.math.BigDecimal stockQtyNotcontains;
  /**
   * 库存数量 比较(startswith)
   */
  private java.math.BigDecimal stockQtyStartswith;
  /**
   * 库存数量 比较(endswith)
   */
  private java.math.BigDecimal stockQtyEndswith;
  /**
   * 库存数量 比较(isnull)
   */
  private Boolean stockQtyIsnull;
  /**
   * 库存数量 比较(isnotnull)
   */
  private Boolean stockQtyIsnotnull;

  /**
   * 库存金额
   */
  private java.math.BigDecimal stockAmount;

  /**
   * 最小库存金额
   */
  private java.math.BigDecimal stockAmountMin;

  /**
   * 最大库存金额
   */
  private java.math.BigDecimal stockAmountMax;

  /**
   * 库存金额 比较(eq)
   */
  private java.math.BigDecimal stockAmountEq;
  /**
   * 库存金额 比较(neq)
   */
  private java.math.BigDecimal stockAmountNeq;
  /**
   * 库存金额 比较(gt)
   */
  private java.math.BigDecimal stockAmountGt;
  /**
   * 库存金额 比较(gte)
   */
  private java.math.BigDecimal stockAmountGte;
  /**
   * 库存金额 比较(lt)
   */
  private java.math.BigDecimal stockAmountLt;
  /**
   * 库存金额 比较(lte)
   */
  private java.math.BigDecimal stockAmountLte;
  /**
   * 库存金额 比较(contains)
   */
  private java.math.BigDecimal stockAmountContains;
  /**
   * 库存金额 比较(notcontains)
   */
  private java.math.BigDecimal stockAmountNotcontains;
  /**
   * 库存金额 比较(startswith)
   */
  private java.math.BigDecimal stockAmountStartswith;
  /**
   * 库存金额 比较(endswith)
   */
  private java.math.BigDecimal stockAmountEndswith;
  /**
   * 库存金额 比较(isnull)
   */
  private Boolean stockAmountIsnull;
  /**
   * 库存金额 比较(isnotnull)
   */
  private Boolean stockAmountIsnotnull;

  /**
   * 辅助数量
   */
  private java.math.BigDecimal auxQty;

  /**
   * 最小辅助数量
   */
  private java.math.BigDecimal auxQtyMin;

  /**
   * 最大辅助数量
   */
  private java.math.BigDecimal auxQtyMax;

  /**
   * 辅助数量 比较(eq)
   */
  private java.math.BigDecimal auxQtyEq;
  /**
   * 辅助数量 比较(neq)
   */
  private java.math.BigDecimal auxQtyNeq;
  /**
   * 辅助数量 比较(gt)
   */
  private java.math.BigDecimal auxQtyGt;
  /**
   * 辅助数量 比较(gte)
   */
  private java.math.BigDecimal auxQtyGte;
  /**
   * 辅助数量 比较(lt)
   */
  private java.math.BigDecimal auxQtyLt;
  /**
   * 辅助数量 比较(lte)
   */
  private java.math.BigDecimal auxQtyLte;
  /**
   * 辅助数量 比较(contains)
   */
  private java.math.BigDecimal auxQtyContains;
  /**
   * 辅助数量 比较(notcontains)
   */
  private java.math.BigDecimal auxQtyNotcontains;
  /**
   * 辅助数量 比较(startswith)
   */
  private java.math.BigDecimal auxQtyStartswith;
  /**
   * 辅助数量 比较(endswith)
   */
  private java.math.BigDecimal auxQtyEndswith;
  /**
   * 辅助数量 比较(isnull)
   */
  private Boolean auxQtyIsnull;
  /**
   * 辅助数量 比较(isnotnull)
   */
  private Boolean auxQtyIsnotnull;

  /**
   * 锁库数量
   */
  private java.math.BigDecimal lockQty;

  /**
   * 最小锁库数量
   */
  private java.math.BigDecimal lockQtyMin;

  /**
   * 最大锁库数量
   */
  private java.math.BigDecimal lockQtyMax;

  /**
   * 锁库数量 比较(eq)
   */
  private java.math.BigDecimal lockQtyEq;
  /**
   * 锁库数量 比较(neq)
   */
  private java.math.BigDecimal lockQtyNeq;
  /**
   * 锁库数量 比较(gt)
   */
  private java.math.BigDecimal lockQtyGt;
  /**
   * 锁库数量 比较(gte)
   */
  private java.math.BigDecimal lockQtyGte;
  /**
   * 锁库数量 比较(lt)
   */
  private java.math.BigDecimal lockQtyLt;
  /**
   * 锁库数量 比较(lte)
   */
  private java.math.BigDecimal lockQtyLte;
  /**
   * 锁库数量 比较(contains)
   */
  private java.math.BigDecimal lockQtyContains;
  /**
   * 锁库数量 比较(notcontains)
   */
  private java.math.BigDecimal lockQtyNotcontains;
  /**
   * 锁库数量 比较(startswith)
   */
  private java.math.BigDecimal lockQtyStartswith;
  /**
   * 锁库数量 比较(endswith)
   */
  private java.math.BigDecimal lockQtyEndswith;
  /**
   * 锁库数量 比较(isnull)
   */
  private Boolean lockQtyIsnull;
  /**
   * 锁库数量 比较(isnotnull)
   */
  private Boolean lockQtyIsnotnull;

  /**
   * 陈列数量
   */
  private java.math.BigDecimal displayQty;

  /**
   * 最小陈列数量
   */
  private java.math.BigDecimal displayQtyMin;

  /**
   * 最大陈列数量
   */
  private java.math.BigDecimal displayQtyMax;

  /**
   * 陈列数量 比较(eq)
   */
  private java.math.BigDecimal displayQtyEq;
  /**
   * 陈列数量 比较(neq)
   */
  private java.math.BigDecimal displayQtyNeq;
  /**
   * 陈列数量 比较(gt)
   */
  private java.math.BigDecimal displayQtyGt;
  /**
   * 陈列数量 比较(gte)
   */
  private java.math.BigDecimal displayQtyGte;
  /**
   * 陈列数量 比较(lt)
   */
  private java.math.BigDecimal displayQtyLt;
  /**
   * 陈列数量 比较(lte)
   */
  private java.math.BigDecimal displayQtyLte;
  /**
   * 陈列数量 比较(contains)
   */
  private java.math.BigDecimal displayQtyContains;
  /**
   * 陈列数量 比较(notcontains)
   */
  private java.math.BigDecimal displayQtyNotcontains;
  /**
   * 陈列数量 比较(startswith)
   */
  private java.math.BigDecimal displayQtyStartswith;
  /**
   * 陈列数量 比较(endswith)
   */
  private java.math.BigDecimal displayQtyEndswith;
  /**
   * 陈列数量 比较(isnull)
   */
  private Boolean displayQtyIsnull;
  /**
   * 陈列数量 比较(isnotnull)
   */
  private Boolean displayQtyIsnotnull;

  /**
   * 残次数量
   */
  private java.math.BigDecimal defectQty;

  /**
   * 最小残次数量
   */
  private java.math.BigDecimal defectQtyMin;

  /**
   * 最大残次数量
   */
  private java.math.BigDecimal defectQtyMax;

  /**
   * 残次数量 比较(eq)
   */
  private java.math.BigDecimal defectQtyEq;
  /**
   * 残次数量 比较(neq)
   */
  private java.math.BigDecimal defectQtyNeq;
  /**
   * 残次数量 比较(gt)
   */
  private java.math.BigDecimal defectQtyGt;
  /**
   * 残次数量 比较(gte)
   */
  private java.math.BigDecimal defectQtyGte;
  /**
   * 残次数量 比较(lt)
   */
  private java.math.BigDecimal defectQtyLt;
  /**
   * 残次数量 比较(lte)
   */
  private java.math.BigDecimal defectQtyLte;
  /**
   * 残次数量 比较(contains)
   */
  private java.math.BigDecimal defectQtyContains;
  /**
   * 残次数量 比较(notcontains)
   */
  private java.math.BigDecimal defectQtyNotcontains;
  /**
   * 残次数量 比较(startswith)
   */
  private java.math.BigDecimal defectQtyStartswith;
  /**
   * 残次数量 比较(endswith)
   */
  private java.math.BigDecimal defectQtyEndswith;
  /**
   * 残次数量 比较(isnull)
   */
  private Boolean defectQtyIsnull;
  /**
   * 残次数量 比较(isnotnull)
   */
  private Boolean defectQtyIsnotnull;

  /**
   * 在途数量
   */
  private java.math.BigDecimal wayQty;

  /**
   * 最小在途数量
   */
  private java.math.BigDecimal wayQtyMin;

  /**
   * 最大在途数量
   */
  private java.math.BigDecimal wayQtyMax;

  /**
   * 在途数量 比较(eq)
   */
  private java.math.BigDecimal wayQtyEq;
  /**
   * 在途数量 比较(neq)
   */
  private java.math.BigDecimal wayQtyNeq;
  /**
   * 在途数量 比较(gt)
   */
  private java.math.BigDecimal wayQtyGt;
  /**
   * 在途数量 比较(gte)
   */
  private java.math.BigDecimal wayQtyGte;
  /**
   * 在途数量 比较(lt)
   */
  private java.math.BigDecimal wayQtyLt;
  /**
   * 在途数量 比较(lte)
   */
  private java.math.BigDecimal wayQtyLte;
  /**
   * 在途数量 比较(contains)
   */
  private java.math.BigDecimal wayQtyContains;
  /**
   * 在途数量 比较(notcontains)
   */
  private java.math.BigDecimal wayQtyNotcontains;
  /**
   * 在途数量 比较(startswith)
   */
  private java.math.BigDecimal wayQtyStartswith;
  /**
   * 在途数量 比较(endswith)
   */
  private java.math.BigDecimal wayQtyEndswith;
  /**
   * 在途数量 比较(isnull)
   */
  private Boolean wayQtyIsnull;
  /**
   * 在途数量 比较(isnotnull)
   */
  private Boolean wayQtyIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;
}
